/*
 * Created on 21-ago-2008
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
package com.gestores;

import com.beans.EventoBean;
import com.beans.UsuarioBean;
import com.util.Conectar;
import com.util.Utils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import javax.naming.NamingException;

/**
 * @author vPalomo
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class GestionEventos {
    //private static GestionEventos instancia=null;
    
    private GestionEventos() {} //Constructor privado, para que nadie pueda usarle
    
    public static synchronized GestionEventos getInstance() {
//        if(instancia==null) {
//            instancia=new GestionEventos();
//        }
//        return instancia;
        return new GestionEventos();
    }
    
    /**
     * Crea en la base de datos un nuevo evento con los datos que se le pasen en el EventoBean. Antes
     * de hacer el alta se comprueba si el usuario tiene o no permiso para crear ese evento en el area.
     * @param datos EventoBean con los datos el evento que se quiere crear.
     * @param usuario Bean del usuario que quiere crear el evento, para asegurarnos que tiene permiso
     * en ese area.
     * @return True si se ha podido crear(no creo que no se pueda nunca) y false si da algun error el alta
     * o el usuario no tiene permiso para crear eventos en ese area.
     */
    public boolean crearEvento(EventoBean datos, UsuarioBean usuario) {
        System.out.println("dentro");
        if(!usuarioValido(usuario,datos.getIdArea())){ 
            System.out.println("Usuario no valido");
            return false;
        }
        System.out.println("Usuario valido");
        //Hace el insert en la base de datos.
        String SQL="insert into eventos(fechaEvento, descripcion, horaEvento, autor, idArea,lugar)"+
            " values(?,?,?,?,?,?)";
        Connection con = null;
        try {
            con=Conectar.getConnection();
            PreparedStatement insert=con.prepareStatement(SQL);
            insert.setString(1,Utils.fechaParaMysql(datos.getFecheEvento()));
            insert.setString(2,datos.getDescripcion());
            insert.setString(3,datos.getHoraEvento());
            insert.setString(4,usuario.getNick());
            insert.setString(5,datos.getIdArea());
            insert.setString(6,datos.getLugar());
            insert.executeUpdate();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }
        return true;   
    }
    /**
     * Comprueba si el usuario pasado tiene permisos en los Eventos y si tiene permiso en el area que 
     * est� creando el evento
     * @param usu Usuario del que queremos hacer la consulta
     * @param area Area que queremos que compruebe. La categoria se sabe que es la de eventos, por eso
     * no se necesita, pero de hace tambien la comparacion
     * @return true si el usuario es valido tanto en la categoria como en el area, false si no tiene permisos
     * en la categoria o en el area.
     */
    private boolean usuarioValido(UsuarioBean usu, String area) {
        if(!usu.categoriaValida("7")){ //El 7 indica que los eventos son la categoria 7, si fuesen la 6 habria que cambiarlo
            System.out.println("Categoria no valida");
            return false;
        }
        if(!usu.areaValida(area)) {
            System.out.println("Area no valida: "+area);
            return false;
        }
        return true;
        
    }
    /**
     * Le pasamos un evento y un usuario, modifica el contenido del evento en la base de datos, pero solo si el usuario tiene permisos y 
     * el evento es suyo (si es su autor).
     * @param datos
     * @param usuario
     * @return
     */
    public boolean modificarEvento(EventoBean datos, UsuarioBean usuario){
        if(!usuarioValido(usuario,datos.getIdArea())){ 
            return false;
        }
        if(!usuario.getNick().equalsIgnoreCase(datos.getAutor())) { //Si el autor y el usuarioBean no coinciden no se har� la actualizacion
            return false;
        }
        String SQL="update eventos set fechaEvento=?, descripcion=?, horaEvento=?, autor=?, idArea=?, lugar=?"+
                " where idEvento=?";        
        
        Connection con = null;
        PreparedStatement update=null;
        try {
            con=Conectar.getConnection();
            update=con.prepareStatement(SQL);
            update.setString(1,Utils.fechaParaMysql(datos.getFecheEvento()));
            update.setString(2,datos.getDescripcion());
            update.setString(3,datos.getHoraEvento());
            update.setString(4,datos.getAutor());
            update.setString(5,datos.getIdArea());
            update.setString(6,datos.getLugar());
            update.setString(7,datos.getIdEvento());
            //System.out.println("Actualizacion "+update.toString());
            update.execute();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if(update!=null)update.close();
                if(con!=null)con.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        return true;
    }
    
    public EventoBean consultarEvento(String id){
        String SQL="select * from eventos where idEvento=?";        
        EventoBean evento=null;
        Connection con = null;
        PreparedStatement select=null;
        ResultSet rs=null;
        try {
            con=Conectar.getConnection();
            select=con.prepareStatement(SQL);
            select.setString(1, id);
            rs=select.executeQuery();
            if(rs.next()){
                evento=new EventoBean();
                evento.setFecheEvento(Utils.fecha(rs.getString("fechaEvento")));
                evento.setIdEvento(rs.getString("idEvento"));
                evento.setDescripcion(rs.getString("descripcion"));
                evento.setHoraEvento(rs.getString("horaEvento"));
                evento.setIdArea(rs.getString("idArea"));
                evento.setAutor(rs.getString("autor"));
                evento.setLugar(rs.getString("lugar"));
            }
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if(rs!=null)rs.close();
                if(con!=null)con.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        return evento;
    }
    /**
     * Elimina el evento que pasemos, solo si el usuario es el autor.
     * @param datos Evento, lo mejor es antes de eliminar hacer la consulta
     * y al eliminar pasarle lo que nos devuelve la consulta
     * @param usuario Usuario que intente eliminar el evento, debe ser el autor
     * @return true si se borra y false si no se borrar(por falta de permisos, por no ser el autor, errores)
     * aunque no debería fallar nunca.
     */
    public boolean eliminarEvento(EventoBean datos, UsuarioBean usuario){
        //Por seguridad. Consultamos los datos en la BD porque podría ser que los
        //datos que nos envien no tengan bien el autor. Con esto nos aseguramos
        //que solo el autor puede eliminar el evento. El usuario no tendrá
        //problemas de permisos ya que viene de la session.
        datos=consultarEvento(datos.getIdEvento());
        
        if(!usuarioValido(usuario,datos.getIdArea())){ 
            return false;
        }
        if(!usuario.getNick().equalsIgnoreCase(datos.getAutor())) { //Si el autor y el usuarioBean no coinciden no se har� la actualizacion
            return false;
        }
        String SQL="delete from eventos where idEvento=?";        
        
        Connection con = null;
        PreparedStatement delete=null;
        try {
            con=Conectar.getConnection();
            delete=con.prepareStatement(SQL);
            delete.setString(1, datos.getIdEvento());
            delete.execute();
        } catch (NamingException ex) {
            ex.printStackTrace();
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if(delete!=null)delete.close();
                if(con!=null)con.close();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        return true;
    }
}
